perm filename BK[P,JRA]1 blob sn#493086 filedate 1980-01-13 generic text, type C, neo UTF8
COMMENT āŠ—   VALID 00002 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00002 00002
C00009 ENDMK
CāŠ—;

rough outline of lisp book

This book should be a lisp programming text that instills, style, quality,
understanding of abstraction, as well  as thoughtfulness.  Though it is  a
programming text, it  is NOT just  a manual.  A  major difficulty in  LISP
programming manuals has been their inability to communicate style as  well
as language mechanics. The effect is to give a very "flat" picture of  the
language.

Besides (or instead of?) the usual program structuring admonitions, a LISP
text must also  convey an appreciation  for appropriate abstraction.   The
burden here is  greater than  in other  languages:  LISP  gives more  data
structuring tools than  other languages; as  a result the  power, and  its
possible misuse, are greater in LISP than in less endowed languages.   For
example, LISP supplies basic constructors, selectors, and recognizers  for
implementing the user's abstractions, yet  the existing texts do not  make
it clear that the user must supply a discipline to their usage. A lack  of
such care leads to obscure programming.

Furthermore, LISP supplies many  programming tools and techniques that are
not available  with a  traditional programming  language. These  novelties
range from language flexibilities --made  possible by the fluidity of  the
language (program/data duality) and  its runtime system  (property-lists),
to economies in programming effort --made possible by placing the language
in a interactive  setting. All of  these facets must  be explained if  the
full power of the language is to  be exploited. Thus, this LISP text is  a
part  of  combined  system:   an  inexpensive  personal  LISP  machine  in
conjunction with a programming text.

The LISP machine should not be thought of as simply a teaching aid, to  be
used in learning  LISP, and then  recycled.  Rather, the  LISP vehicle  is
basis for developing  software, just  like any other  language (or  system
like UCSD Pascal).   A difference (and  advantage) with LISP  is that  the
range of application  available to the  LISP person is  much greater  than
with a traditional language; but note: it  is not that one can do in  LISP
some computation that CANNOT be done  in another, it is only that  complex
programming is often EASIER and faster in LISP.

With this background, a brief outline follows. Remember, that the book  is
to be read  in conjunction with  interaction on the  maccine. It will  not
require a teacher however; an "electronic" teacher will be included in the
system.

what is lisp
	description of history, applications areas
	
	system supplies canned games for the  user (e.g eliza
	 adventure, macsyma-ish, ...)

using the system
	as a calculator
	 simple arithmetic, string, and array facilities

	as an online teacher
	 hand-holding through simple programs using above
	  facilities; n.b. this is in list notation
	  (system may present completed program segments for the 
	   user to run, for example)

abstraction
	abstraction in data
	 the concept: an example
	 its implementation in above
	 its implementation as list-structure

	abstraction in program 
	 idea of control
		 recursion
		 iteration
		 backtrack[?]

evaluation
	lisp as a machine
	 call-by-value
	less control
	 call-by-pattern-match

property-lists
	data-driven programming
	data bases
	smalltalk in lisp

program as data
	role of editor
		debugger
		compiler[?]

data as program
	functional args[?]

special languages as solutions to problems
	complex problems are seldom answered by a 
	 simple solution; they can be couched as
	 read-eval-print for  special languages

	construction of evaluators
	 recursive
	 non-recursive

input/output
	streams
	data base
	parser/unparsers
	

general overview of lisp
	its culture and future

introduction to ai
	applications
	 business
	 industry
	 education
	 leisure
		

system description (manuals)
	editor
	debugger
	language features
	input/output

*****
functions as args
scoping
debugging
macros